// (function(){
//   return typeof arguments;
// })();   //object
//
// var foo = {
//   bar: function() { return this.baz; },
//   baz:  1
// };
// (function(){
//   return typeof arguments[0]();
// })(foo.bar);
// //undefined
//
// console.log([] == ![])   //true  [] == ! []  ->  [] == false -> [] == 0 ->  '' == 0  ->  0 == 0  -> true
// console.log({} == ! {})   //false   {} == ! {}   ->   {} == false  ->  {} == 0  ->   NaN == 0    ->  false
// console.log( Function instanceof Object );   //true
// console.log( Object instanceof Function );   //true  Object created by Function
// console.log( (function f(){}).__proto__ === Function.prototype);  //true

//
// function f(){ return f; }
// console.log(new f() instanceof f);
// // false   a instanceof b 用于检测 a 是不是 b 的实例,本题中 new f() 返回的结果为 f 的函数对象，其并不是 f 的一个 实例
//
// function foo(){
//   this.a = 100;
//   this.b = 200;
// }
//
// function goo(){
//   this.c = 300;
//   this.d = 400;
// }
//
// var seed = new foo();  //1
//
// foo.prototype.fuss = function(fn) {
//   fn.prototype = seed;
//   console.log()
//   seed = new fn;   //2
//   return this;     //3
// }
//
// var a = seed.fuss(goo);
//
// console.log(a.c);    //undefined
// console.log(a === seed );    //false
// console.log(seed.a);     //100


// function foo(){
//   this.a = 100;
//   this.b = 200;
// }
//
// function goo(){
//   this.c = 300;
//   this.d = 400;
// }
//
// var seed = new foo();  //1
//
// foo.prototype.fuss2 = function(fn) {
//   fn.prototype = seed;
//   return new fn;
// }
//
// var a = seed.fuss2(goo);
//
// if ( "fuss2" in a ) {
//   var b = a.fuss2(foo);
// }
//
// console.log(Object.prototype.hasOwnProperty.call(a, "a"));   //false
// console.log("b" in a);   //true
// console.log("fuss2" in a);   //true
// console.log("c" in b);   //false


// const parent = function() {
//   const result = [];
//   const child = ()　=> {
//     for (let num of arguments) {
//       result.push(num);
//     }
//     return result;
//   }
//
//   return child(1, 2, 3);
// }
//
// const result = parent(4, 5, 6, 7);
// console.log(JSON.stringify(result));     //[4,5,6,7]


// var target = function() { return "I am the target"; };
// var handler = {
//   apply: function(receiver, ...args) {
//     return "I am the proxy";
//   }
// };
//
// var p = new Proxy(target, handler);
//
// console.log(p() === "I am the proxy");  //true


// let a = {n : 1};
// let b = a;
// a.x = a = {n: 2};
// console.log(a.x)
// console.log(b.x)
//第一题：分三步：第一步：优先级原因先执行a.x，执行完以后 a,b两个指针都是指向同一对象{n:1,x:undefined}，
// 此时a.x代表的仅是{n:1,x:undefined}中的x的指针；第二步：执行a={n:2}，此时a为{n:2}，b为{n:1,x:undefined}；
// 第三步：执行a.x=a ，注意此时的a.x为对象{n:1.x:undefined}中x属性的的指针；所以执行完以后对象修改为{n:1,x:{n:2}}，
// 第一步中b是这个对象的指针，所以b={n:1,x:{n:2}}。执行完时：a={n:2},b={n:1,x:{n:2}}。

// const a = {
//   // 定义一个属性来做累加
//   i: 0,
//   valueOf () {
//     return this.i++
//   }
// }
// console.log(a == 1 && a == 2 && a == 3)
//  // true

// console.log(9 % -2)   //1
// console.log(-9 % 2)   //-1
// console.log(-9 % -2)   //-1  余数的正负号随第一个操作数
// console.log('5' + 3)   //'53'
// console.log('5' - 3)    //2

// var val = 'smtg';
// console.log('Value is ' + (val === 'smtg') ? 'Something' : 'Nothing');
// //Something 字符串连接比三元运算有更高的优先级
// console.log(1 || fn() && fn())   //1
// console.log(1 || 1 ? 2 : 3)   //2


